﻿#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//int globalVar = 1;
//static int staticGlobalVar = 1;
//void Test()
//{
//	static int staticVar = 1;
//	int localVar = 1;
//	int num1[10] = { 1, 2, 3, 4 };
//	char char2[] = "abcd";
//	const char* pChar3 = "abcd";
//	int* ptr1 = (int*)malloc(sizeof(int) * 4);
//	int* ptr2 = (int*)calloc(4, sizeof(int));
//	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
//	free(ptr1);
//	free(ptr3);
//}

//int main()
//{
//	char a[] = "abcd";
//	char(*pa)[5]  = &a;
//
//	printf("%p\n", a);
//	cout <<pa<< endl;
//	
//	return 0;
//}

//int main()
//{
//	//动态申请一个int类型空间
//	int* p1 = new int;
//
//	//动态申请10个int类型空间
//	int* p2 = new int[10];
//
//	//动态申请一个int类型空间，并初始化为10
//	int* p3 = new int(10);
//
//	//动态申请10个int类型空间，并将前面3个初始化为1,后面默认初始化为0
//	int* p4 = new int[5] {1, 1, 1,};
//
//	//释放空间
//	//new匹配delete，new[]匹配delete[]
//	delete p1;
//	delete[] p2;
//	delete p3;
//	delete[] p4;
//
//	return 0;
//}


//class A
//{
//public:
//	A(int a = 0, int b = 0)
//		:_a(a)
//		,_b(b)
//	{
//		cout << "A(int a)" << endl;
//	}
//	A(const A& a)
//	{
//		_a = a._a;
//		_b = a._b;
//		cout << "A(const A& a)" << endl;
//	}
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//	void Print()
//	{
//		cout << "_a = " << _a << endl;
//	}
//private:
//	int _a = 0;
//	int _b = 0;
//
//};
//
// 
//int main()
//{
//	A* p1 = new A;
//	A* p2 = new A(10);
//
//	p1->Print();
//	p2->Print();
//
//	delete p1;
//	delete p2;
//
//	return 0;
//}

//struct ListNode
//{
//	int val;
//	ListNode* next;
//
//	ListNode(int x = 0)
//		:val(x)
//		,next(nullptr)
//	{}
//
//};

//int main()
//{
//	ListNode* p1 = new ListNode;
//	ListNode* p2 = new ListNode(1);
//	ListNode* p3 = new ListNode(2);
//	p1->next = p2;
//	p2->next = p3;
//
//	delete p1;
//	delete p2;
//	delete p3;
//
//	return 0;
//}

//int main()
//{
//	A* p1 = new A(1, 1);
//	cout << endl;
//
//	//数组多参数给值方法
//	
//	//法一：严格来说这不是调用构造，而是拷贝构造
//	A a1(1, 1);
//	A a2(2, 2);
//	A a3(3, 3);
//	A* p2 = new A[3]{ a1,a2,a3 };
//	cout << endl;
//
//	//法二：匿名对象
//	A* p3 = new A[3]{ A(1,1), A(2,2), A(3,3) };
//	cout << endl;
//
//	//法三：隐式类型转换
//	A* p4 = new A[3]{ {1,1},{2,2}, {3,3} };
//	cout << endl;
//
//	return 0;
//}


//class A
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//	void Print()
//	{
//		cout << "_a = " << _a << endl;
//	}
//private:
//	int _a = 0;
//	int _b = 1;
//};
//int main()
//{
//	A* p = new A;
//	return 0;
//}


//int main()
//{
//	void* p1 = new char[1024 * 1024 * 1024];
//	cout << p1 << endl;
//
//	void* p2 = new char[1024 * 1024 * 1024];
//	cout << p2 << endl;
//
//
//	return 0;
//}


//int main()
//{
//	try
//	{
//		void* p1 = new char[1024 * 1024 * 1024];
//		cout << p1 << endl;
//		void* p2 = new char[1024 * 1024 * 1024];
//		cout << p2 << endl;
//	}
//	catch (const exception& e)
//	{
//		cout << e.what() << endl;
//	}
//	
//	return 0;
//}


void func()
{
	int n = 0;
	while (1)
	{
		n++;
		void* p = new char[1024 * 1024];//一次向堆申请一字节的内存
		cout << p << ":->" << n << endl;
	}
}

//int main()
//{
//	try
//	{
//		func();
//	}
//	catch (const exception& e)
//	{
//		cout << e.what() << endl;
//	}
//	return 0;
//}


/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
*/
//void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
//{
//	// try to allocate size bytes
//	void* p;
//	while ((p = malloc(size)) == 0)
//		if (_callnewh(size) == 0)
//		{
//			// report no memory
//			// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
//			static const std::bad_alloc nomem;
//			_RAISE(nomem);
//		}
//	return (p);
//}
//
//
///*
//operator delete: 该函数最终是通过free来释放空间的
//*/
//void operator delete(void* pUserData)
//{
//	_CrtMemBlockHeader* pHead;
//	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
//	if (pUserData == NULL)
//		return;
//	_mlock(_HEAP_LOCK);  /* block other threads */
//	__TRY
//		/* get a pointer to memory block header */
//		pHead = pHdr(pUserData);
//	/* verify block type */
//	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
//	_free_dbg(pUserData, pHead->nBlockUse);
//	__FINALLY
//		_munlock(_HEAP_LOCK);  /* release other threads */
//	__END_TRY_FINALLY
//		return;
//}
///*
//free的实现
//*/
//#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)//free其实是一个宏函数

//
//int main()
//{
//	A* p = new A(1);
//	delete p;
//	return 0;
//}

//int main()
//{
//	A* p1 = new A;
//	free(p1);
//	return 0;
//}

//class B
//{
//private:
//	int _b1 = 1;
//	int _b2 = 2;
//};

//int main()
//{
//	A* p1 = new A[10];
//	delete p1;
//	return 0;
//}
// 
//int main()
//{
//	B* p1 = new B[10];
//	delete p1;
//	return 0;
//}

//int main()
//{
//	A* p1 = new A(1);
//
//	A* p2 = (A*)operator new(sizeof(A));
//	return 0;
//}
//
//class A
//{
//public :
//	A(int a = 0)
//		: _a(a)
//	{
//		cout << "A():" << this << endl;
//	} ~
//		A()
//	{
//		cout << "~A():" << this << endl;
//	}
//private:
//	int _a;
//};

//int main()
//{
//	//A* p1 = new A;
//
//	A* p1 = (A*)operator new(sizeof(A));
//	new(p1)A(1);
//
//	p1->~A();
//	operator delete p1;
//
//	return 0;
//}


class A
{
public:
	A()
	{
		++_scount;
	}
	A(const A& t)
	{
		++_scount;
	}
	~A()
	{
		--_scount;
	}

	//静态成员函数
	static int GetACount()
	{
		return _scount;
	}

private:
	// 类⾥⾯声明
	static int _scount;
};

int A::_scount = 1;
//int main()
//{
//	cout << " " << A::GetACount() << endl;
//	A a1, a2;
//	A a3(a1);
//	cout << " " << A::GetACount() << endl;
//	cout <<  " " << a1.GetACount() << endl;
//
//	return 0;
//}
int main()
{
	cout << " " << A::GetACount() << endl;
	A a1, a2;

	{
		A a3(a1);
		cout <<" " << A::GetACount() << endl;
	}

	cout << " " << a1.GetACount() << endl;

	return 0;
}